1. Field of the Invention
The present invention relates to a screen display processing apparatus for processing the display of a screen on a computer, to a screen display processing method and to a computer program. More particularly, the invention relates to a screen display processing apparatus for processing the display of a computer screen constituted by a plurality of objects, to a screen display processing method and to a computer program.
More specifically, the invention relates to a screen display processing apparatus for processing the display of a GUI screen constituted by a plurality of objects and successively updated together with the user interaction, to a screen display processing method and to a computer program, and particularly to a screen display processing apparatus for efficiently processing the display of a GUI screen by suppressing the drawing of unnecessary objects, to a screen display processing method and to a computer program.
2. Description of Related Art
Accompanying the technical innovation in recent years, general purpose computer systems which are relatively small in size, low at cost, featuring high additional values and high functions, called work stations (WSs) and personal computers (PCs), have been developed, placed in the market, and are deeply infiltrating into universities, research institutions, enterprises, offices, and even into everyday life in general households. Nowadays, most of the daily businesses involve computers, and many people spend a day touching the keyboard and the mouse.
In general, a computer system is driven in response to a user input command and displays the processed results on a display screen (interactive type) to offer an interactive processing environment. Recently, the user input environment of the character base or “CUI (character user interface)” through a traditional keyboard as represented by the DOS (disk operating system) shell screen, is shifting toward the “GUI (graphical user interface)” which realizes the graphic base user input. Under the GUI environment, there are provided a desktop simulating a computer system and a number of icons on a display screen.
On the desktop on which the GUI is provided, resource objects handled on a computer system such as files are all expressed as icons. By using a user input device such as a mouse, the user directly applies (e.g., clicks or drags and drops) an operation to an object displayed on the screen, such as an icon symbolizing a program, a data, a folder or a device on the display screen to operate the computer intuitively and in an easy manner. On the desktop are further provided buttons such as menu bars and tool boxes for instantaneously calling a variety of functions, i.e., computer processings, making it more intuitive and easy to input the command to the computer.
Upon introducing the GUI environment, the user is allowed to operate the computer to a sufficient degree without having to particularly learn the names of particular commands or how to operate the command, and without having to carry out complex key input. The computer further is capable of incorporating a user input faithful to the user's will in the system.
Under the GUI environment, the content (appearance) displayed on the desktop screen is updated at all times. For example, the menu window is opened or closed, the buttons are depressed or released, check boxes are selected and excluded, label text and counter value are updated, etc.
Such a change in the GUI screen is usually regarded to be a damage on the screen display and must be restored or redrawn. For example, when a drop-down menu is closed, the region where the menu had been displayed must be recovered again so as to produce a display as covered with the menu. Or, when a check box is clicked though it had not been selected by the user, the displayed content must be updated from the display of screen that is not selected to the selected display of screen.
In order to restore the damage on the two-dimensional GUI screen as described above, there has been widely employed a method of restoring or redrawing all objects in the damaged region from the rear side toward the front. Namely, the rear farthest object such as background image is drawn, first. Then, front objects closer thereto are successively drawn and, finally, the object which is at the most front is drawn. This method has been known as “painter's algorithm” since the GUI screen is drawn in the same manner as when a painter draws a picture on a canvas. The painter draws, first, the sky and mountains at the back, then, draws trees, houses, etc., and, finally, draws portraits of men at the most front. According to this method, the damage in the damaged region can be reliably restored. In practice, however, the region must be redrawn over the areas several times as wide as the damaged region, driving up the cost of calculation.
For example, when there is a change in the color displaying the button disposed in front of a given image, the region closed with this button is a damaged region which must be restored. In this case, the image portion intersecting the damaged region is redrawn, first, and, then, the button on the above region is redrawn.
Here, if the damaged region is completely smeared out with the button, the button only needs be redrawn for restoring the screen display. This overhead can be accepted in the two-dimensional GUI where the content to be changed is not tremendous and only a small number of objects are overlapped. In the two-and-a-half-dimensional GUI where the zoom and animation functions are added to the two-dimensional display, however, there are displayed a considerable amount of damage and the overlapping of objects, and the overhead readily spreads to a problem of performance of the system.
Here, restoration of the screen of the animation GUI will be considered with reference to FIG. 10. In the illustrated example, a given GUI object is moving from the object boundary box of the previous time surrounding the object to a current object boundary box at an animation step.
A restoration processing for the moving object is basically constituted by two simple animation steps. That is, the drawing processing must be executed at a new position to where the object has moved while the initial position must be smeared with the background image (see FIG. 11). The processing for restoring the damage is executed for every step.
As a general method to substitute for the “painter's algorithm”, there can be exemplified a “z-buffer algorithm”. This algorithm manages the so-called z-buffer to maintain the z-order, i.e., to maintain the order of objects in the previous draw processing. That is, whenever the draw processing is executed at a given position, the z-buffer is checked, first, and it is judged whether the draw processing has been completed already at the above position. When the previous draw processing exists in front of the current draw processing on the z-order, the content of the current draw processing is discarded. This algorithm requires additional checking but can omit the draw processing and, hence, features performance which is still better than that of the painter's algorithm. With the z-buffer algorithm, it is judged at all times whether a given region is smeared out already in front or what the z-order is. Therefore, there is no need of drawing the object according to a predetermined order.
As compared to the painter's algorithm, the z-buffer algorithm has a defect in that it requires an additional memory for the z-buffer. Therefore, this application is unrealistic for the apparatus that has a limitation on the memory. Further, this algorithm is applied to a three-dimensional GUI which operates on a system having high performance such as executing the draw processing in a unit of the pixel. That is, as for the recent draw processing, the z-buffer contains the data related to the z-order for each of the pixels. When the drawing is to be processed maintaining such a fine resolution, the z-buffer checking is virtually impossible on a system having a relatively small calculation ability. Besides, since no particular order has been specified for drawing the GUI objects, there still exists a probability of effecting the unnecessary drawing as described above.
As another method of updating the display of the GUI screen, there can be exemplified a reverse painter's algorithm which is constituted by a combination of the painter's algorithm and the z-buffer algorithm. This method is, generally, the same as the z-buffer algorithm, according to which, however, the GUI objects must be drawn in order opposite to that of the z-order, i.e., from the front side toward the rear side. Though this avoids the unnecessary draw processing, the z-buffer still have to bear a large burden of memory overhead.